/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.qsdm.es.dao;

import com.qsdm.es.dao.exceptions.NonexistentEntityException;
import com.qsdm.es.dao.exceptions.PreexistingEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import com.qsdm.es.persistence.Curso;
import com.qsdm.es.persistence.Horariocurso;
import com.qsdm.es.persistence.HorariocursoPK;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.transaction.UserTransaction;

/**
 *
 * @author alberto
 */
public class HorariocursoJpaController extends BasicJpaController {

    public void create(Horariocurso horariocurso) throws PreexistingEntityException, Exception {
        if (horariocurso.getHorariocursoPK() == null) {
            horariocurso.setHorariocursoPK(new HorariocursoPK());
        }
        horariocurso.getHorariocursoPK().setCurso(horariocurso.getCurso1().getId());
        EntityManager em = null;
        try {
            em = getEntityManager();
            
            Curso curso1 = horariocurso.getCurso1();
            if (curso1 != null) {
                curso1 = em.getReference(curso1.getClass(), curso1.getId());
                horariocurso.setCurso1(curso1);
            }
            em.persist(horariocurso);
            if (curso1 != null) {
                curso1.getHorariocursoList().add(horariocurso);
                curso1 = em.merge(curso1);
            }
            
        } catch (Exception ex) {
            if (findHorariocurso(horariocurso.getHorariocursoPK()) != null) {
                throw new PreexistingEntityException("Horariocurso " + horariocurso + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Horariocurso horariocurso) throws NonexistentEntityException, Exception {
        horariocurso.getHorariocursoPK().setCurso(horariocurso.getCurso1().getId());
        EntityManager em = null;
        try {
            em = getEntityManager();
            
            Horariocurso persistentHorariocurso = em.find(Horariocurso.class, horariocurso.getHorariocursoPK());
            Curso curso1Old = persistentHorariocurso.getCurso1();
            Curso curso1New = horariocurso.getCurso1();
            if (curso1New != null) {
                curso1New = em.getReference(curso1New.getClass(), curso1New.getId());
                horariocurso.setCurso1(curso1New);
            }
            horariocurso = em.merge(horariocurso);
            if (curso1Old != null && !curso1Old.equals(curso1New)) {
                curso1Old.getHorariocursoList().remove(horariocurso);
                curso1Old = em.merge(curso1Old);
            }
            if (curso1New != null && !curso1New.equals(curso1Old)) {
                curso1New.getHorariocursoList().add(horariocurso);
                curso1New = em.merge(curso1New);
            }
            
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                HorariocursoPK id = horariocurso.getHorariocursoPK();
                if (findHorariocurso(id) == null) {
                    throw new NonexistentEntityException("The horariocurso with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(HorariocursoPK id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            
            Horariocurso horariocurso;
            try {
                horariocurso = em.getReference(Horariocurso.class, id);
                horariocurso.getHorariocursoPK();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The horariocurso with id " + id + " no longer exists.", enfe);
            }
            Curso curso1 = horariocurso.getCurso1();
            if (curso1 != null) {
                curso1.getHorariocursoList().remove(horariocurso);
                curso1 = em.merge(curso1);
            }
            em.remove(horariocurso);
            
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Horariocurso> findHorariocursoEntities() {
        return findHorariocursoEntities(true, -1, -1);
    }

    public List<Horariocurso> findHorariocursoEntities(int maxResults, int firstResult) {
        return findHorariocursoEntities(false, maxResults, firstResult);
    }

    private List<Horariocurso> findHorariocursoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Horariocurso.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Horariocurso findHorariocurso(HorariocursoPK id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Horariocurso.class, id);
        } finally {
            em.close();
        }
    }

    public int getHorariocursoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Horariocurso> rt = cq.from(Horariocurso.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
